{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|default_exp analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">fastai Learner extensions useful to perform prediction analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "import inspect\n",
    "\n",
    "import sklearn.metrics as skm\n",
    "from fastai.interpret import *\n",
    "from fastai.learner import *\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from tsai.data.core import *\n",
    "from tsai.data.preprocessing import *\n",
    "from tsai.imports import *\n",
    "from tsai.inference import *\n",
    "from tsai.utils import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "@patch\n",
    "@delegates(subplots)\n",
    "def show_probas(self:Learner, figsize=(6,6), ds_idx=1, dl=None, one_batch=False, max_n=None, **kwargs):\n",
    "    recorder = copy(self.recorder) # This is to avoid loss of recorded values while generating preds\n",
    "    if dl is None: dl = self.dls[ds_idx]\n",
    "    if one_batch: dl = [dl.one_batch()]\n",
    "    probas, targets = self.get_preds(dl=dl)\n",
    "    if probas.ndim == 2 and probas.min() < 0 or probas.max() > 1: probas = nn.Softmax(-1)(probas)\n",
    "    if not isinstance(targets[0].item(), Integral): return\n",
    "    targets = targets.flatten()\n",
    "    if max_n is not None:\n",
    "        idxs = random_choice(len(probas), max_n, False)\n",
    "        probas, targets = probas[idxs], targets[idxs]\n",
    "    if isinstance(probas, torch.Tensor): probas = probas.detach().cpu().numpy()\n",
    "    if isinstance(targets, torch.Tensor): targets = targets.detach().cpu().numpy()\n",
    "    fig = plt.figure(figsize=figsize, **kwargs)\n",
    "    classes = np.unique(targets)\n",
    "    nclasses = len(classes)\n",
    "    vals = np.linspace(.5, .5 + nclasses - 1, nclasses)[::-1]\n",
    "    plt.vlines(.5, min(vals) - 1, max(vals), color='black', linewidth=.5)\n",
    "    cm = plt.get_cmap('gist_rainbow')\n",
    "    color = [cm(1.* c/nclasses) for c in range(1, nclasses + 1)][::-1]\n",
    "    # class_probas = np.array([probas[i,t] for i,t in enumerate(targets)])\n",
    "    class_probas = np.array([probas[i][t] for i,t in enumerate(targets)])\n",
    "    for i, c in enumerate(classes):\n",
    "        plt.scatter(class_probas[targets == c] if nclasses > 2 or i > 0 else 1 - class_probas[targets == c],\n",
    "                    targets[targets == c] + .5 * (np.random.rand((targets == c).sum()) - .5), color=color[i], edgecolor='black', alpha=.2, s=100)\n",
    "        if nclasses > 2: plt.vlines((targets == c).mean(), i - .5, i + .5, color='r', linewidth=.5)\n",
    "    plt.hlines(vals, 0, 1)\n",
    "    plt.ylim(min(vals) - 1, max(vals))\n",
    "    plt.xlim(0,1)\n",
    "    plt.xticks(np.linspace(0,1,11), fontsize=12)\n",
    "    plt.yticks(classes, [self.dls.vocab[x] for x in classes], fontsize=12)\n",
    "    plt.title('Predicted proba per true class' if nclasses > 2 else 'Predicted class 1 proba per true class', fontsize=14)\n",
    "    plt.xlabel('Probability', fontsize=12)\n",
    "    plt.ylabel('True class', fontsize=12)\n",
    "    plt.grid(axis='x', color='gainsboro', linewidth=.2)\n",
    "    plt.show()\n",
    "    self.recorder = recorder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "@patch\n",
    "def plot_confusion_matrix(self:Learner, ds_idx=1, dl=None, thr=.5, normalize=False, title='Confusion matrix', cmap=\"Blues\", norm_dec=2, figsize=(5,5),\n",
    "                          title_fontsize=12, fontsize=10, plot_txt=True, **kwargs):\n",
    "        \"Plot the confusion matrix, with `title` and using `cmap`.\"\n",
    "        # This function is mainly copied from the sklearn docs\n",
    "        if dl is None: dl = self.dls[ds_idx]\n",
    "        assert dl.cat\n",
    "        if dl.c == 2: # binary classification\n",
    "            probas, preds = self.get_preds(dl=dl)\n",
    "            y_pred = (probas[:, 1] > thr).numpy().astype(int)\n",
    "            y_test = preds.numpy()\n",
    "            if normalize: skm_normalize = 'true'\n",
    "            else: skm_normalize = None\n",
    "            cm = skm.confusion_matrix(y_test, y_pred, normalize=skm_normalize)\n",
    "        else: \n",
    "            cm = ClassificationInterpretation.from_learner(self).confusion_matrix()\n",
    "\n",
    "        if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        fig = plt.figure(figsize=figsize, **kwargs)\n",
    "        plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "        if self.dls.c == 2:\n",
    "            plt.title(f\"{title} (threshold: {thr})\", fontsize=title_fontsize)\n",
    "        else: \n",
    "            plt.title(title, fontsize=title_fontsize)\n",
    "        tick_marks = np.arange(len(self.dls.vocab))\n",
    "        plt.xticks(tick_marks, self.dls.vocab, rotation=90, fontsize=fontsize)\n",
    "        plt.yticks(tick_marks, self.dls.vocab, rotation=0, fontsize=fontsize)\n",
    "\n",
    "        if plot_txt:\n",
    "            thresh = cm.max() / 2.\n",
    "            for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "                coeff = f'{cm[i, j]:.{norm_dec}f}' if normalize else f'{cm[i, j]}'\n",
    "                plt.text(j, i, coeff, horizontalalignment=\"center\", verticalalignment=\"center\", color=\"white\" if cm[i, j] > thresh else \"black\", fontsize=fontsize)\n",
    "\n",
    "        ax = fig.gca()\n",
    "        ax.set_ylim(len(self.dls.vocab)-.5,-.5)\n",
    "\n",
    "        plt.tight_layout()\n",
    "        plt.ylabel('Actual', fontsize=fontsize)\n",
    "        plt.xlabel('Predicted', fontsize=fontsize)\n",
    "        plt.grid(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "@patch\n",
    "def top_losses(self:Learner,\n",
    "    X, # array-like object representing the independent variables\n",
    "    y, # array-like object representing the target\n",
    "    k:int=9, # Optional. #items to plot\n",
    "    largest=True, # Flag to show largest or smallest losses\n",
    "    bs:int=64, # batch size\n",
    "    ):\n",
    "    *_, losses = self.get_X_preds(X, y, bs=bs, with_loss=True)\n",
    "    top_losses, idxs = losses.topk(ifnone(k, len(losses)), largest=largest)\n",
    "    idxs = idxs.tolist()\n",
    "    return top_losses, idxs\n",
    "\n",
    "@patch\n",
    "def plot_top_losses(self:Learner,\n",
    "    X, # array-like object representing the independent variables\n",
    "    y, # array-like object representing the target\n",
    "    k:int=9, # Optional. #items to plot\n",
    "    largest=True, # Flag to show largest or smallest losses\n",
    "    bs:int=64, # batch size\n",
    "    **kwargs, # show_batch kwargs\n",
    "    ):\n",
    "    *_, losses = self.get_X_preds(X, y, bs=bs, with_loss=True)\n",
    "    idxs = losses.topk(ifnone(k, len(losses)), largest=largest)[1].tolist()\n",
    "    dl = self.dls.valid.new_dl(X[idxs], y=y[idxs], bs=k)\n",
    "    b = dl.one_batch()\n",
    "    dl.show_batch(b, max_n=k, **kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Permutation importance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've also introduced 2 methods to help you better understand how important certain features or certain steps are for your model. Both methods use permutation importance. \n",
    "\n",
    "⚠️**The permutation feature or step importance is defined as the decrease in a model score when a single feature or step value is randomly shuffled.**\n",
    "\n",
    "So if you using accuracy (higher is better), the most important features or steps will be those with a *lower* value on the chart (as randomly shuffling them reduces performance). \n",
    "\n",
    "The opposite occurs for metrics like mean squared error (lower is better). In this case, the most important features or steps will be those with a *higher* value on the chart. \n",
    "\n",
    "There are 2 issues with step importance: \n",
    "\n",
    "* there may be many steps and the analysis could take very long\n",
    "* steps will likely have a high autocorrelation\n",
    "\n",
    "For those reasons, we've introduced an argument (n_steps) to group steps. In this way you'll be able to know which part of the time series is the most important. \n",
    "\n",
    "Feature importance has been adapted from https://www.kaggle.com/cdeotte/lstm-feature-importance by Chris Deotte (Kaggle GrandMaster)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "@patch\n",
    "def feature_importance(self:Learner, \n",
    "    X=None, # array-like object containing the time series. If None, all data in the validation set will be used.\n",
    "    y=None, # array-like object containing the targets. If None, all targets in the validation set will be used.\n",
    "    bs:int=None, # batch size. If None, the default batch size of the dataloader will be used.\n",
    "    partial_n:(int, float)=None, # # (int) or % (float) of used to measure feature importance. If None, all data will be used.\n",
    "    method:str='permutation', # Method used to invalidate feature. Use 'permutation' for shuffling or 'ablation' for setting values to np.nan.\n",
    "    feature_names:list=None, # Optional list of feature names that will be displayed if available. Otherwise var_0, var_1, etc.\n",
    "    sel_classes:(str, list)=None, # classes for which the analysis will be made\n",
    "    key_metric_idx:int=0, # Optional position of the metric used. If None or no metric is available, the loss will be used.\n",
    "    show_chart:bool=True, # Flag to indicate if a chart showing permutation feature importance will be plotted.\n",
    "    figsize:tuple=None, # Size of the chart.\n",
    "    title:str=None, # Optional string that will be used as the chart title. If None 'Permutation Feature Importance'.\n",
    "    return_df:bool=True, # Flag to indicate if the dataframe with feature importance will be returned.\n",
    "    save_df_path:Path=None, # Path where dataframe containing the permutation feature importance results will be saved.\n",
    "    random_state:int=23, # Optional int that controls the shuffling applied to the data.\n",
    "    verbose:bool=True, # Flag that controls verbosity.\n",
    "    ):\n",
    "    r\"\"\"Calculates feature importance as the drop in the model's validation loss or metric when a feature value is randomly shuffled\"\"\"\n",
    "    \n",
    "    assert method in ['permutation', 'ablation']\n",
    "\n",
    "    # X, y\n",
    "    if X is None:\n",
    "        X = self.dls.train.dataset.tls[0].items\n",
    "        if hasattr(self.dls.train.dataset.tls[0], '_splits'): X = X[self.dls.train.dataset.tls[0]._splits]\n",
    "    if y is None:\n",
    "        y = self.dls.train.dataset.tls[1].items\n",
    "    if partial_n is not None:\n",
    "        _, rand_idxs, *_ = train_test_split(np.arange(len(y)), y, test_size=partial_n, random_state=random_state, stratify=y)\n",
    "        X = X.oindex[rand_idxs] if hasattr(X, 'oindex') else X[rand_idxs]\n",
    "        y = y.oindex[rand_idxs] if hasattr(y, 'oindex') else y[rand_idxs]\n",
    "    else: \n",
    "        X, y = X[:], y[:]\n",
    "    if sel_classes is not None:\n",
    "        filt = np.isin(y, listify(sel_classes))\n",
    "        X, y = X[filt], y[filt]\n",
    "    pv(f'X.shape: {X.shape}', verbose)\n",
    "    pv(f'y.shape: {y.shape}', verbose)\n",
    "    if bs is None:\n",
    "        bs = self.dls.valid.bs\n",
    "\n",
    "    # Metrics\n",
    "    metrics = [mn for mn in self.recorder.metric_names if mn not in ['epoch', 'train_loss', 'valid_loss', 'time']]\n",
    "    if len(metrics) == 0 or key_metric_idx is None:\n",
    "        metric_name = self.loss_func.__class__.__name__\n",
    "        key_metric_idx = None\n",
    "    else:\n",
    "        metric_name = metrics[key_metric_idx]\n",
    "        metric = self.recorder.metrics[key_metric_idx].func\n",
    "        if \"sklearn\" in inspect.getmodule(metric).__name__:\n",
    "            sklearn_metric = True\n",
    "        else:\n",
    "            sklearn_metric = False\n",
    "    metric_name = metric_name.replace(\"train_\", \"\").replace(\"valid_\", \"\")\n",
    "    pv(f'Selected metric: {metric_name}', verbose)\n",
    "\n",
    "    # Selected vars & feature names\n",
    "    sel_vars = not(isinstance(self.dls.sel_vars, slice) and self.dls.sel_vars == slice(None, None, None))\n",
    "    if feature_names is None:\n",
    "        feature_names = L([f\"var_{i}\" for i in range(X.shape[1])])\n",
    "        if sel_vars:\n",
    "            feature_names = feature_names[self.dls.sel_vars]\n",
    "    else:\n",
    "        feature_names = listify(feature_names)\n",
    "\n",
    "    if sel_vars:\n",
    "        assert len(feature_names) == len(self.dls.sel_vars)\n",
    "    else:\n",
    "        assert len(feature_names) == X.shape[1]\n",
    "    sel_var_idxs = L(np.arange(X.shape[1]).tolist())\n",
    "    if sel_vars:\n",
    "        sel_var_idxs = sel_var_idxs[self.dls.sel_vars]\n",
    "    assert len(feature_names) == len(sel_var_idxs)\n",
    "    g = list(zip(np.arange(len(sel_var_idxs)+2), [0] + sel_var_idxs))\n",
    "    \n",
    "    # Loop\n",
    "    COLS = ['BASELINE'] + list(feature_names)\n",
    "    results = []\n",
    "    pv(f'Computing feature importance ({method} method)...', verbose)\n",
    "    try:\n",
    "        if method == 'ablation':\n",
    "            fs = self.dls.valid.after_batch.fs\n",
    "            self.dls.valid.after_batch.fs = fs + [TSNan2Value()]\n",
    "        for i,k in progress_bar(g):\n",
    "            if i > 0:\n",
    "                if k not in sel_var_idxs: continue\n",
    "                save_feat = X[:, k].copy()\n",
    "                if method == 'permutation':\n",
    "                    # shuffle along samples & steps\n",
    "                    X[:, k] = random_shuffle(X[:, k].flatten(), random_state=random_state).reshape(X[:, k].shape)\n",
    "                elif method == 'ablation':\n",
    "                    X[:, k] = np.nan\n",
    "            if key_metric_idx is None:\n",
    "                value = self.get_X_preds(X, y, with_loss=True, with_decoded=False, bs=bs)[-1].mean().item()\n",
    "            else:\n",
    "                output = self.get_X_preds(X, y, with_decoded=False, bs=bs)\n",
    "                if self.dls.c == 2:\n",
    "                    try: \n",
    "                        if sklearn_metric:\n",
    "                            value = metric(output[1], output[0][:, 1]).item()\n",
    "                        else:\n",
    "                            value = metric(output[0][:, 1], output[1]).item()\n",
    "                    except: \n",
    "                        if sklearn_metric:\n",
    "                            value = metric(output[1], output[0]).item()\n",
    "                        else:\n",
    "                            value = metric(output[0], output[1]).item()\n",
    "                else:\n",
    "                    if sklearn_metric:\n",
    "                        value = metric(output[1], output[0]).item()\n",
    "                    else:\n",
    "                        value = metric(output[0], output[1]).item()\n",
    "                del output\n",
    "            pv(f\"{k:3} feature: {COLS[i]:20} {metric_name}: {value:8.6f}\", verbose)\n",
    "            results.append([COLS[i], value])\n",
    "            del value; gc.collect()\n",
    "            if i > 0:\n",
    "                X[:, k] = save_feat\n",
    "                del save_feat; gc.collect()\n",
    "        \n",
    "        if method == 'ablation':\n",
    "            self.dls.valid.after_batch.fs = fs\n",
    "\n",
    "    except KeyboardInterrupt:\n",
    "        if i > 0:\n",
    "            X[:, k] = save_feat\n",
    "            del save_feat; gc.collect()\n",
    "        if method == 'ablation':\n",
    "            self.dls.valid.after_batch.fs = fs\n",
    "\n",
    "    # DataFrame\n",
    "    df = pd.DataFrame(results, columns=[\"Feature\", metric_name])\n",
    "    df[f'{metric_name}_change'] = df[metric_name] - df.loc[0, metric_name]\n",
    "    sign = np.sign(df[f'{metric_name}_change'].mean())\n",
    "    if sign == 0: sign = 1\n",
    "    df[f'{metric_name}_change'] = df[f'{metric_name}_change'] * sign\n",
    "\n",
    "    # Display feature importance\n",
    "    if show_chart:\n",
    "        print()\n",
    "        value_change = df.loc[1:, f'{metric_name}_change'].values\n",
    "        pos_value_change = value_change.copy()\n",
    "        neg_value_change = value_change.copy()\n",
    "        pos_value_change[pos_value_change < 0] = 0\n",
    "        neg_value_change[neg_value_change > 0] = 0\n",
    "        if figsize is None:\n",
    "            figsize=(10, .5*len(value_change))\n",
    "        plt.figure(figsize=figsize)\n",
    "        plt.barh(np.arange(len(value_change))[::-1], pos_value_change, color='lime', edgecolor='black')\n",
    "        plt.barh(np.arange(len(value_change))[::-1], neg_value_change, color='red', edgecolor='black')\n",
    "        plt.axvline(0, color='black')\n",
    "        plt.yticks(np.arange(len(value_change))[::-1], df.loc[1:, \"Feature\"].values)\n",
    "        if title is None: title = f'Feature Importance ({method} method)'\n",
    "        plt.title(title, size=16)\n",
    "        text = 'increase' if sign == 1 else 'decrease'\n",
    "        plt.xlabel(f\"{metric_name} {text} when feature is removed\")\n",
    "        plt.ylim((-1,len(value_change)))\n",
    "        plt.show()\n",
    "\n",
    "    # Save feature importance\n",
    "    df = df.sort_values(metric_name, ascending=sign < 0, kind='stable').reset_index(drop=True)\n",
    "    if save_df_path:\n",
    "        if save_df_path.split('.')[-1] != 'csv': save_df_path = f'{save_df_path}.csv'\n",
    "        df.to_csv(f'{save_df_path}', index=False)\n",
    "        pv(f'Feature importance df saved to {save_df_path}', verbose)\n",
    "    if return_df: \n",
    "        return df "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "@patch\n",
    "def step_importance(\n",
    "    self:Learner, \n",
    "    X=None, # array-like object containing the time series. If None, all data in the validation set will be used.\n",
    "    y=None, # array-like object containing the targets. If None, all targets in the validation set will be used.\n",
    "    bs:int=None, # batch size used to compute predictions. If None, the batch size used in the validation set will be used.\n",
    "    partial_n:(int, float)=None, # # (int) or % (float) of used to measure feature importance. If None, all data will be used.\n",
    "    method:str='permutation', # Method used to invalidate feature. Use 'permutation' for shuffling or 'ablation' for setting values to np.nan.\n",
    "    step_names:list=None, # Optional list of step names that will be displayed if available. Otherwise 0, 1, 2, etc.\n",
    "    sel_classes:(str, list)=None, # classes for which the analysis will be made\n",
    "    n_steps:int=1, # # of steps that will be analyzed at a time. Default is 1.\n",
    "    key_metric_idx:int=0, # Optional position of the metric used. If None or no metric is available, the loss will be used.\n",
    "    show_chart:bool=True, # Flag to indicate if a chart showing permutation feature importance will be plotted.\n",
    "    figsize:tuple=(10, 5), # Size of the chart.\n",
    "    title:str=None, # Optional string that will be used as the chart title. If None 'Permutation Feature Importance'.\n",
    "    xlabel=None, # Optional string that will be used as the chart xlabel. If None 'steps'.\n",
    "    return_df:bool=True, # Flag to indicate if the dataframe with feature importance will be returned.\n",
    "    save_df_path:Path=None, # Path where dataframe containing the permutation feature importance results will be saved.\n",
    "    random_state:int=23, # Optional int that controls the shuffling applied to the data.\n",
    "    verbose:bool=True, # Flag that controls verbosity.\n",
    "    ):\n",
    "    r\"\"\"Calculates step importance as the drop in the model's validation loss or metric when a step/s value/s is/are randomly shuffled\"\"\"\n",
    "    \n",
    "    assert method in ['permutation', 'ablation']\n",
    "    \n",
    "    # X, y\n",
    "    if X is None:\n",
    "        X = self.dls.train.dataset.tls[0].items\n",
    "        if hasattr(self.dls.train.dataset.tls[0], '_splits'): X = X[self.dls.train.dataset.tls[0]._splits]\n",
    "    if y is None:\n",
    "        y = self.dls.train.dataset.tls[1].items\n",
    "    if partial_n is not None:\n",
    "        _, rand_idxs, *_ = train_test_split(np.arange(len(y)), y, test_size=partial_n, random_state=random_state, stratify=y)\n",
    "        X = X.oindex[rand_idxs] if hasattr(X, 'oindex') else X[rand_idxs]\n",
    "        y = y.oindex[rand_idxs] if hasattr(y, 'oindex') else y[rand_idxs]\n",
    "    else: \n",
    "        X, y = X[:], y[:]\n",
    "    if sel_classes is not None:\n",
    "        filt = np.isin(y, listify(sel_classes))\n",
    "        X, y = X[filt], y[filt]\n",
    "    pv(f'X.shape: {X.shape}', verbose)\n",
    "    pv(f'y.shape: {y.shape}', verbose)\n",
    "    if bs is None:\n",
    "        bs = self.dls.valid.bs\n",
    "\n",
    "    # Metrics\n",
    "    metrics = [mn for mn in self.recorder.metric_names if mn not in ['epoch', 'train_loss', 'valid_loss', 'time']]\n",
    "    if len(metrics) == 0 or key_metric_idx is None:\n",
    "        metric_name = self.loss_func.__class__.__name__\n",
    "        key_metric_idx = None\n",
    "    else:\n",
    "        metric_name = metrics[key_metric_idx]\n",
    "        metric = self.recorder.metrics[key_metric_idx].func\n",
    "        if \"sklearn\" in inspect.getmodule(metric).__name__:\n",
    "            sklearn_metric = True\n",
    "        else:\n",
    "            sklearn_metric = False\n",
    "    metric_name = metric_name.replace(\"train_\", \"\").replace(\"valid_\", \"\")\n",
    "    pv(f'Selected metric: {metric_name}', verbose)\n",
    "    \n",
    "    # Selected steps\n",
    "    sel_step_idxs = L(np.arange(X.shape[-1]).tolist())[self.dls.sel_steps]\n",
    "    if n_steps != 1:\n",
    "        sel_step_idxs = [listify(sel_step_idxs[::-1][n:n+n_steps][::-1]) for n in range(0, len(sel_step_idxs), n_steps)][::-1]     \n",
    "    g = list(zip(np.arange(len(sel_step_idxs)+2), [0] + sel_step_idxs))\n",
    "\n",
    "    # Loop\n",
    "    COLS = ['BASELINE'] + sel_step_idxs\n",
    "    results = []\n",
    "    _step_names = []\n",
    "    pv('Computing step importance...', verbose)\n",
    "    try:\n",
    "        if method == 'ablation':\n",
    "            fs = self.dls.valid.after_batch.fs\n",
    "            self.dls.valid.after_batch.fs = fs + [TSNan2Value()]\n",
    "        for i,k in progress_bar(g):\n",
    "            if i > 0:\n",
    "                if k not in sel_step_idxs: continue\n",
    "                save_feat = X[..., k].copy()\n",
    "                if method == 'permutation':\n",
    "                    # shuffle along samples\n",
    "                    X[..., k] = shuffle_along_axis(X[..., k], axis=0, random_state=random_state)\n",
    "                elif method == 'ablation':\n",
    "                    X[..., k] = np.nan\n",
    "            if key_metric_idx is None:\n",
    "                value = self.get_X_preds(X, y, bs=bs, with_loss=True, with_decoded=False)[-1].mean().item()\n",
    "            else:\n",
    "                output = self.get_X_preds(X, y, bs=bs, with_decoded=False)\n",
    "                if self.dls.c == 2:\n",
    "                    try: \n",
    "                        if sklearn_metric:\n",
    "                            value = metric(output[1], output[0][:, 1]).item()\n",
    "                        else:\n",
    "                            value = metric(output[0][:, 1], output[1]).item()\n",
    "                    except: \n",
    "                        if sklearn_metric:\n",
    "                            value = metric(output[1], output[0]).item()\n",
    "                        else:\n",
    "                            value = metric(output[0], output[1]).item()\n",
    "                else:\n",
    "                    if sklearn_metric:\n",
    "                        value = metric(output[1], output[0]).item()\n",
    "                    else:\n",
    "                        value = metric(output[0], output[1]).item()\n",
    "                del output\n",
    "            \n",
    "            # Step names\n",
    "            if i == 0 or step_names is None:\n",
    "                if i > 0 and n_steps != 1:\n",
    "                    step_name = f\"{str(COLS[i][0])} to {str(COLS[i][-1])}\"\n",
    "                else: step_name = str(COLS[i])\n",
    "            else:\n",
    "                step_name = step_names[i - 1]\n",
    "            if i > 0: _step_names.append(step_name)\n",
    "                \n",
    "            pv(f\"{i:3} step: {step_name:20} {metric_name}: {value:8.6f}\", verbose)\n",
    "            results.append([step_name, value])\n",
    "            del value; gc.collect()\n",
    "            if i > 0:\n",
    "                X[..., k] = save_feat\n",
    "                del save_feat; gc.collect()\n",
    "        \n",
    "        if method == 'ablation':\n",
    "            self.dls.valid.after_batch.fs = fs\n",
    "\n",
    "    except KeyboardInterrupt:\n",
    "        if i > 0:\n",
    "            X[..., k] = save_feat\n",
    "            del save_feat; gc.collect()\n",
    "        if method == 'ablation':\n",
    "            self.dls.valid.after_batch.fs = fs\n",
    "\n",
    "    # DataFrame\n",
    "    df = pd.DataFrame(results, columns=[\"Step\", metric_name])\n",
    "    df[f'{metric_name}_change'] = df[metric_name] - df.loc[0, metric_name]\n",
    "    sign = np.sign(df[f'{metric_name}_change'].mean())\n",
    "    if sign == 0: sign = 1\n",
    "    df[f'{metric_name}_change'] = df[f'{metric_name}_change'] * sign\n",
    "    \n",
    "    # Display step importance\n",
    "    if show_chart:\n",
    "        print()\n",
    "        value_change = df.loc[1:, f'{metric_name}_change'].values\n",
    "        pos_value_change = value_change.copy()\n",
    "        neg_value_change = value_change.copy()\n",
    "        pos_value_change[pos_value_change < 0] = 0\n",
    "        neg_value_change[neg_value_change > 0] = 0\n",
    "        plt.figure(figsize=figsize)\n",
    "        plt.bar(np.arange(len(value_change)), pos_value_change, color='lime', edgecolor='black')\n",
    "        plt.bar(np.arange(len(value_change)), neg_value_change, color='red', edgecolor='black')\n",
    "        plt.axhline(0, color='black')\n",
    "        plt.xticks(np.arange(len(value_change)), _step_names, rotation=90)\n",
    "        if title is None: title = f'Step Importance ({method} method)'\n",
    "        plt.title(title, size=16)\n",
    "        text = 'increase' if sign == 1 else 'decrease'\n",
    "        if xlabel is None: xlabel = 'steps'\n",
    "        plt.xlabel(xlabel)\n",
    "        plt.ylabel(f\"{metric_name} {text} when removed\")\n",
    "        plt.xlim((-1,len(value_change)))\n",
    "        plt.show()\n",
    "\n",
    "    # Save step importance\n",
    "    df = df.sort_values(metric_name, ascending=sign < 0, kind='stable').reset_index(drop=True)\n",
    "    if save_df_path:\n",
    "        if save_df_path.split('.')[-1] != 'csv': save_df_path = f'{save_df_path}.csv'\n",
    "        df.to_csv(f'{save_df_path}', index=False)\n",
    "        pv(f'Step importance df saved to {save_df_path}', verbose)\n",
    "    if return_df: \n",
    "        return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tsai.data.external import get_UCR_data\n",
    "from tsai.data.preprocessing import TSRobustScale, TSStandardize\n",
    "from tsai.learner import ts_learner\n",
    "from tsai.models.FCNPlus import FCNPlus\n",
    "from tsai.metrics import accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>train_accuracy</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>valid_accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.792511</td>\n",
       "      <td>0.187500</td>\n",
       "      <td>1.619460</td>\n",
       "      <td>0.216667</td>\n",
       "      <td>00:02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.592681</td>\n",
       "      <td>0.632812</td>\n",
       "      <td>1.475991</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>00:01</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1300x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(TensorBase([2.3713, 2.3146, 2.2843, 2.2581, 2.2408, 2.2264, 2.2254, 2.2237,\n",
       "             2.2230]),\n",
       " [9, 56, 128, 25, 104, 116, 57, 72, 108])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1800x1200 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dsid = 'NATOPS'\n",
    "X, y, splits = get_UCR_data(dsid, split_data=False)\n",
    "tfms  = [None, [TSClassification()]]\n",
    "batch_tfms = TSRobustScale()\n",
    "batch_tfms = TSStandardize()\n",
    "dls = get_ts_dls(X, y, splits=splits, sel_vars=[0, 3, 5, 8, 10], sel_steps=slice(-30, None), tfms=tfms, batch_tfms=batch_tfms)\n",
    "learn = ts_learner(dls, FCNPlus, metrics=accuracy, train_metrics=True)\n",
    "learn.fit_one_cycle(2)\n",
    "learn.plot_metrics()\n",
    "learn.show_probas()\n",
    "learn.plot_confusion_matrix()\n",
    "learn.plot_top_losses(X[splits[1]], y[splits[1]], largest=True)\n",
    "learn.top_losses(X[splits[1]], y[splits[1]], largest=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X.shape: (180, 24, 51)\n",
      "y.shape: (180,)\n",
      "Selected metric: accuracy\n",
      "Computing feature importance (permutation method)...\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      <progress value='6' class='' max='6' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [6/6 00:04&lt;00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0 feature: BASELINE             accuracy: 0.277778\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0 feature: var_0                accuracy: 0.238889\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  3 feature: var_3                accuracy: 0.172222\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  5 feature: var_5                accuracy: 0.261111\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  8 feature: var_8                accuracy: 0.250000\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 10 feature: var_10               accuracy: 0.266667\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Feature</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>accuracy_change</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>var_3</td>\n",
       "      <td>0.172222</td>\n",
       "      <td>0.105556</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>var_0</td>\n",
       "      <td>0.238889</td>\n",
       "      <td>0.038889</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>var_8</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.027778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>var_5</td>\n",
       "      <td>0.261111</td>\n",
       "      <td>0.016667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>var_10</td>\n",
       "      <td>0.266667</td>\n",
       "      <td>0.011111</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>BASELINE</td>\n",
       "      <td>0.277778</td>\n",
       "      <td>-0.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Feature  accuracy  accuracy_change\n",
       "0     var_3  0.172222         0.105556\n",
       "1     var_0  0.238889         0.038889\n",
       "2     var_8  0.250000         0.027778\n",
       "3     var_5  0.261111         0.016667\n",
       "4    var_10  0.266667         0.011111\n",
       "5  BASELINE  0.277778        -0.000000"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.feature_importance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X.shape: (180, 24, 51)\n",
      "y.shape: (180,)\n",
      "Selected metric: accuracy\n",
      "Computing step importance...\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      <progress value='7' class='' max='7' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [7/7 00:04&lt;00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0 step: BASELINE             accuracy: 0.277778\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1 step: 21 to 25             accuracy: 0.288889\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  2 step: 26 to 30             accuracy: 0.255556\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  3 step: 31 to 35             accuracy: 0.194444\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  4 step: 36 to 40             accuracy: 0.216667\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  5 step: 41 to 45             accuracy: 0.272222\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  6 step: 46 to 50             accuracy: 0.283333\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.step_importance(n_steps=5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may pass an X and y if you want to analyze a particular group of samples: \n",
    "\n",
    "```bash\n",
    "learn.feature_importance(X=X[splits[1]], y=y[splits[1]])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have a large validation dataset, you may also use the partial_n argument to select a fixed amount of samples (integer) or a percentage of the validation dataset (float):\n",
    "\n",
    "```bash\n",
    "learn.feature_importance(partial_n=.1)\n",
    "```\n",
    "\n",
    "```bash\n",
    "learn.feature_importance(partial_n=100)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": "IPython.notebook.save_checkpoint();",
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/nacho/notebooks/tsai/nbs/020_analysis.ipynb couldn't be saved automatically. You should save it manually 👋\n",
      "Correct notebook to script conversion! 😃\n",
      "Monday 19/06/23 09:53:06 CEST\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio  controls=\"controls\" autoplay=\"autoplay\">\n",
       "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#|eval: false\n",
    "#|hide\n",
    "from tsai.export import get_nb_name; nb_name = get_nb_name(locals())\n",
    "from tsai.imports import create_scripts; create_scripts(nb_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
